//#include <iostream>
//using namespace std;
//
//const int N = 1e5 + 10;
//
//int a[N] = { 0 };
//int f[N] = { 0 };
//int len = 0;
//int n;
//
//int main()
//{
//    cin >> n;
//    for (int i = 1; i <= n; i++)
//    {
//        cin >> a[i];
//    }
//    for (int i = 1; i <= n; i++)
//    {
//        if (len == 0 || a[i] > f[len])
//        {
//            f[++len] = a[i];
//        }
//        else
//        {
//            int left = 1;
//            int right = len;
//            while (left < right)
//            {
//                int mid = (left + right) / 2;
//                if (f[mid] >= a[i])
//                    right = mid;
//                else
//                    left = mid + 1;
//            }
//
//            f[left] = a[i];
//        }
//    }
//    cout << len << endl;
//
//    return 0;
//}


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
//class Solution {
//public:
//    ListNode* mergeKLists(vector<ListNode*>& lists)
//    {
//        vector<int> a;
//        for (auto p : lists)
//        {
//            ListNode* cur = p;
//            ListNode* next = nullptr;
//            while (cur)
//            {
//                next = cur->next;
//                a.push_back(cur->val);
//                delete cur;
//                cur = next;
//            }
//        }
//
//        sort(a.begin(), a.end());
//
//        ListNode* ret = nullptr;
//        ListNode* tail = nullptr;
//
//
//        for (auto ch : a)
//        {
//            ListNode* newnode = new ListNode();
//            newnode->next = nullptr;
//            newnode->val = ch;
//            if (ret == nullptr)
//            {
//                ret = newnode;
//                tail = newnode;
//            }
//            else
//            {
//                tail->next = newnode;
//                tail = newnode;
//            }
//        }
//
//        return ret;
//    }
//};




//class Solution {
//public:
//    ListNode* mergeKLists(vector<ListNode*>& lists)
//    {
//        vector<int> a;
//        for (auto p : lists)
//        {
//            ListNode* cur = p;
//            ListNode* next = nullptr;
//            while (cur)
//            {
//                next = cur->next;
//                a.push_back(cur->val);
//                delete cur;
//                cur = next;
//            }
//        }
//
//        sort(a.begin(), a.end());
//
//        ListNode* ret = nullptr;
//        ListNode* tail = nullptr;
//
//
//        for (auto ch : a)
//        {
//            ListNode* newnode = new ListNode();
//            newnode->next = nullptr;
//            newnode->val = ch;
//            if (ret == nullptr)
//            {
//                ret = newnode;
//                tail = newnode;
//            }
//            else
//            {
//                tail->next = newnode;
//                tail = newnode;
//            }
//        }
//
//        return ret;
//    }
//};



//class Solution {
//public:
//    int dfs(TreeNode* root)
//    {
//        if (root == nullptr)
//            return 0;
//
//        int left = dfs(root->left);
//        int right = dfs(root->right);
//
//        return 1 + max(left, right);
//    }
//    int maxDepth(TreeNode* root)
//    {
//        return dfs(root);
//    }
//};


//class Solution {
//public:
//    bool dfs(TreeNode* root, long long* val)
//    {
//        if (root == nullptr)
//            return 1;
//
//        if (dfs(root->left, val) == 0)
//            return 0;
//
//        if (root->val <= (*val))
//            return 0;
//        *val = root->val;
//
//        if (dfs(root->right, val) == 0)
//            return 0;
//
//        return 1;
//    }
//    bool isValidBST(TreeNode* root)
//    {
//        long long val = -1e18;
//        return dfs(root, &val);
//    }
//};



#include <iostream>
using namespace std;

typedef long long ll;

const int N = 5e3 + 10;
const int MOD = 1e9 + 7;

int n;
ll cnt[N] = { 0 };

int main()
{
	cin >> n;
	int mx = 0;
	for (int i = 1; i <= n; i++)
	{
		int x;
		cin >> x;
		mx = max(mx, x);
		cnt[x]++;
	}

	ll ret = 0;

	for (int i = 1; i <= mx; i++)
	{
		if (cnt[i] < 2)
			continue;

		ll tmp = (cnt[i] * (cnt[i] - 1)) / 2;
		ll num = 0;
		for (int j = 1; 2 * j <= i; j++)
		{
			if (cnt[j] > 0 && cnt[i - j] > 0)
			{
				if (i - j == j)
				{
					num += (cnt[j] * (cnt[j] - 1)) / 2;
				}
				else
				{
					num += cnt[j] * cnt[i - j];
				}
				num %= MOD;
			}
		}

		ret += tmp * num;
		ret %= MOD;
	}

	cout << ret << endl;

	return 0;
}